home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 051-060 / amok58 / stack&queue / stack.mod < prev    next >
Text File  |  1993-11-04  |  4KB  |  119 lines
  1. (* ==================================================================== *)
  2. (* === Stack ========================================================== *)
  3. (* ==================================================================== *)
  4. (*
  5.  
  6.   :Program.       Stack.MOD
  7.   :Contents.      stack ADT based on linear lists
  8.   :Author.        Peter Fröhlich [phf]
  9.   :Copyright.     Public Domain
  10.   :Language.      Oberon (revised)
  11.   :Translator.    Amiga Oberon V2.01
  12.   :History.       V0.0 [phf] 02-Sep-1991 [created]
  13.   :History.       V1.0 [phf] 03-Sep-1991 seems to work
  14.   :History.       V1.0 [phf] 08-Sep-1991 [last edit]
  15.  
  16.   :Support.       B. Meyer, Object-oriented Software Construction
  17.   :Imports.       -
  18.   :Bugs.          none known
  19.  
  20.   :Address.       Ebenböckstraße 19, D-8000 München 60
  21.   :Address.       Z-NET:P.FROEHLICH@NEXT-BOX.ZER
  22.   :Phone.         (089) 820 31 72
  23.  
  24. *)
  25. (* ==================================================================== *)
  26.  
  27. MODULE Stack;
  28.  
  29. (* ==================================================================== *)
  30. (* === Imports ======================================================== *)
  31. (* ==================================================================== *)
  32.  
  33. IMPORT
  34.   l : Lists;
  35.  
  36. (* ==================================================================== *)
  37. (* === Types ========================================================== *)
  38. (* ==================================================================== *)
  39.  
  40. TYPE
  41.   Element* = POINTER TO ElementObject;
  42.   ElementObject* = l.Node; (* exported to allow type-extension *)
  43.           
  44.   Stack* = POINTER TO l.List;
  45.  
  46. (* ==================================================================== *)
  47. (* === Procedures ===================================================== *)
  48. (* ==================================================================== *)
  49.  
  50. (*==== Stack creation/destruction ======================================*)
  51.  
  52. (* --- Create --------------------------------------------------------- *)
  53. PROCEDURE Create*(VAR (*OUT*) stack: Stack);
  54. BEGIN
  55.   NEW(stack);
  56.   IF (stack # NIL) THEN
  57.     l.Init(stack^);
  58.   END;
  59. END Create;
  60. (* -------------------------------------------------------------------- *)
  61.  
  62. (* --- Discard -------------------------------------------------------- *)
  63. PROCEDURE Discard*(VAR (*INOUT*) stack: Stack);
  64. BEGIN
  65.   DISPOSE(stack);
  66.   stack := NIL;
  67. END Discard;
  68. (* -------------------------------------------------------------------- *)
  69.  
  70. (*==== Accessing a stack ===============================================*)
  71.  
  72. (* --- Push ----------------------------------------------------------- *)
  73. PROCEDURE Push*(VAR (*INOUT*) stack: Stack; element: Element);
  74. BEGIN
  75.   l.AddHead(stack^,element);
  76. END Push;
  77. (* -------------------------------------------------------------------- *)
  78.  
  79. (* --- Pop ------------------------------------------------------------ *)
  80. PROCEDURE Pop*(VAR (*INOUT*) stack: Stack): Element;
  81. BEGIN
  82.   RETURN l.RemHead(stack^);
  83. END Pop;
  84. (* -------------------------------------------------------------------- *)
  85.  
  86. (* --- Top ------------------------------------------------------------ *)
  87. PROCEDURE Top*(VAR (*IN*) stack: Stack): Element;
  88. BEGIN
  89.   RETURN l.Head(stack^);
  90. END Top;
  91. (* -------------------------------------------------------------------- *)
  92.  
  93. (*==== Status of a stack ===============================================*)
  94.  
  95. (* --- Empty ---------------------------------------------------------- *)
  96. PROCEDURE Empty*(VAR (*IN*) stack: Stack): BOOLEAN;
  97. BEGIN
  98.   RETURN l.Empty(stack^);
  99. END Empty;
  100. (* -------------------------------------------------------------------- *)
  101.  
  102. (* --- Full ----------------------------------------------------------- *)
  103. PROCEDURE Full*(VAR (*IN*) stack: Stack): BOOLEAN;
  104. BEGIN
  105.   RETURN FALSE; (* this implementation can never be full *)
  106. END Full;
  107. (* -------------------------------------------------------------------- *)
  108.  
  109. (* --- Elements ------------------------------------------------------- *)
  110. PROCEDURE Elements*(VAR (*IN*) stack: Stack): LONGINT;
  111. BEGIN
  112.   RETURN l.CountElements(stack^);
  113. END Elements;
  114. (* -------------------------------------------------------------------- *)
  115.  
  116. (* ==================================================================== *)
  117. END Stack.
  118. (* ==================================================================== *)
  119.